package com.beemans.corekit.duplicate;

import android.os.Handler;
import android.os.Looper;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;

import java.io.File;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Android 平台的重复文件扫描器
 * 提供线程安全的扫描操作，支持取消和进度回调
 */
public class AndroidDuplicateScanner {
    @NonNull
    private final AdvancedDuplicateScanner scanner;
    @NonNull
    private final Handler mainHandler;
    @Nullable
    private ExecutorService executor;

    /**
     * 使用默认配置创建扫描器
     */
    public AndroidDuplicateScanner() {
        this(5);
    }

    /**
     * 创建扫描器并指定最大扫描深度
     * 
     * @param maxDepth 最大扫描深度（目录层级）
     */
    public AndroidDuplicateScanner(int maxDepth) {
        this.scanner = new AdvancedDuplicateScanner(maxDepth);
        this.mainHandler = new Handler(Looper.getMainLooper());
    }

    /**
     * 开始扫描重复文件
     * 
     * @param rootDirectory 要扫描的根目录
     * @param listener 扫描结果监听器
     */
    public void startScan(@NonNull File rootDirectory, @NonNull ScanListener listener) {
        // 先取消之前的扫描
        cancelScan();

        // 创建新的执行器
        executor = Executors.newSingleThreadExecutor();

        // 设置扫描监听器（使用代理模式将回调转发到主线程）
        scanner.setScanListener(new ScanListener() {
            @Override
            public void onScanProgress(int scannedFiles, int potentialDuplicates) {
                mainHandler.post(() -> listener.onScanProgress(scannedFiles, potentialDuplicates));
            }

            @Override
            public void onDuplicateFound(@NonNull List<File> duplicateGroup) {
                mainHandler.post(() -> listener.onDuplicateFound(duplicateGroup));
            }

            @Override
            public void onScanCompleted(@NonNull List<List<File>> allDuplicates) {
                // 这个方法不会在 scanner 中调用，由下面的逻辑处理
            }

            @Override
            public void onScanError(@NonNull String error) {
                // 这个方法不会在 scanner 中调用，由下面的逻辑处理
            }
        });

        // 在后台线程执行扫描
        executor.execute(() -> {
            try {
                List<List<File>> duplicates = scanner.scanDuplicateFiles(rootDirectory);
                mainHandler.post(() -> listener.onScanCompleted(duplicates));
            } catch (Exception e) {
                final String errorMessage = e.getMessage() != null ? e.getMessage() : "Unknown error occurred";
                mainHandler.post(() -> listener.onScanError(errorMessage));
            }
        });
    }

    /**
     * 取消当前正在进行的扫描
     */
    public void cancelScan() {
        // 通知 scanner 取消
        scanner.cancelScan();

        // 关闭执行器
        if (executor != null && !executor.isShutdown()) {
            executor.shutdownNow();
            executor = null;
        }
    }

    /**
     * 设置最大扫描深度
     * 
     * @param maxDepth 最大深度
     */
    public void setMaxDepth(int maxDepth) {
        scanner.setMaxDepth(maxDepth);
    }

    /**
     * 设置是否对小文件使用完整哈希
     * 
     * @param useFullHash true 表示使用完整哈希，false 表示使用部分哈希
     */
    public void setUseFullHashForSmallFiles(boolean useFullHash) {
        scanner.setUseFullHashForSmallFiles(useFullHash);
    }

    /**
     * 添加要排除的目录名称
     * 
     * @param directoryName 目录名称（不区分大小写）
     */
    public void addExcludedDirectory(@NonNull String directoryName) {
        scanner.addExcludedDirectory(directoryName);
    }

    /**
     * 释放资源
     * 应该在不再需要扫描器时调用
     */
    public void release() {
        cancelScan();
    }
}